<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        //Promise
        //Promise本身是一个构造函数  new Promise（） 返回一个Promise对象（鸭子模型：拥有then方法就是Promise对象）
        //Promise有三种状态。等待状态pending，已解决fullfild（resolved），已拒绝rejected。默认等待状态pending
        //Promise状态只能由等待pending变为已解决resolved，或者是由等待pending变为已拒绝rejected   状态一旦修改了，就不能再变了，早构造函数中，必须要把状态改为resolve或reject
        //Promise构造函数里有一个参数，这个参数是一个回调函数，这个回调函数有两个参数，这两个参数分别为resolve，reject，resolve是一个把状态由等待改为成功的方法，reject是一个把状态由等待改为失败的方法
        //Promise构造函数里的回调函数里，一定要调用resolve或reject把状态修改
        //Promise有单个实例方法：then方法，catch方法，finally方法
        // Promise使用then方法接受resolve方法传过来的数据
        //Promise使用catch方法接收reject方法传过来的数据
        //Promise对象的finally方法代表无论成功还是失败最后一定会执行的
        // Promise的静态方法：Promise.resolve()方法把状态改为成功，Promise.reject()方法把状态改为失败，all方法解决并发的异步操作
        //Promise.all方法，实现异步请求并发的方法，所有并发的请求全部成功才算成功,

        //面试题：状态只能等待改为成功，或等待改为失败，new Promise一旦执行力就不能中断
        //在构造函数内部返回一个空的Promise实例即可
        new Promise((resolve,reject) => {

        })












        //

        // new Promise((resolve,reject)=>{
        //     setTimeout(() =>{
        //         console.log('这是个异步请求');
        //         if(Math.random() > 0.5){
        //             resolve('异步请求获取的数据')
        //         }else{
        //             reject('失败的数据')
        //         }
        //     },1000)
        // }).then(res => {
        //     console.log(res);
        // }).catch(err => {
        //     console.log(err);
        // })


        //  new Promise((resolve,reject) => {
        //     setTimeout(() => {
        //         console.log('这是一个异步请求');
        //         if(Math.random() > 0.5){
        //             resolve ('异步请求出来的数据')
        //         }else{
        //             reject('失败的数据')
        //         }
        //     },1000)
        //  }).then(brr => {
        //     console.log(brr);
        //  }).catch(naa => {
        //     console.log(naa);
        //  })


        //  new Promise((res, rej) =>{
        //     setTimeout(() => {
        //         console.log('这是一个异步请求');
        //         if(Math.random() > 0.5){
        //             res("请求成功")
        //         }else{
        //             rej('失败')
        //         }
        //     },1000)
        //  }).then( ar =>{
        //     console.log(ar);
        //  }).catch(br => {
        //     console.log(br);
        //  })
    
        
        // const p = new Promise((res ,rej) => {
        //     setTimeout(()=> {
        //         if(Math.random() > 0.5){
        //             res('请求成功')
        //         }else{
        //             rej('请求失败')
        //         }
        //     },1000)
        // })

        // console.log(performance);
        //Promise实例的方法可以有第二个参数，第二个参数，第二个参数就相当于catch方法，是用来捕获错误的
        //如果then方法有第二个参数，那么Promise实例对象的carch方法不会执行

        // p.then(res => {
        //     console.log(res);
        // },err => {
        //     console.log(err);
        // }).catch(err => {
        //     console.log(err);
        // }).finally(() => {
        //     console.log("该方法无论成功还是失败最后一定会执行");
        // })

        //Promise.all方法实现异步并发功能。该方法的参数是一个数组
        const p1 = new Promise((res,rej) => {
            setTimeout(() =>{
               if(Math.random() > 0.5){
                    
                    res('第一个成功异步请求，延迟500ms')
                    console.log('第一个成功异步请求，延迟500ms');
               }else{
                    rej('第一个失败异步请求，延迟500ms');
                    console.log('第一个失败异步请求，延迟500ms');
               }
            },500)
        })
        const p2 = new Promise((res,rej) => {
            setTimeout(() =>{
                if(Math.random() > 0.5){
                    res('第二个成功异步请求，延迟1000ms');
                    console.log('第二个成功异步请求，延迟1000ms');
               }else{
                    rej('第二个失败异步请求，延迟1000ms');
                    console.log('第二个失败异步请求，延迟1000ms');
               }
            },1000)
        })
        const p3 = new Promise((res,rej) => {
            setTimeout(() =>{
                if(Math.random() > 0.5){
                    res('第三个成功异步请求，延迟2000ms');
                    console.log('第三个成功异步请求，延迟2000ms');
               }else{
                    rej('第三个失败异步请求，延迟2000ms');
                    console.log('第三个失败异步请求，延迟2000ms');
               }
            },2000)
        })
        // 静态方法
        Promise.all([p1,p2,p3]).then(ber => {
            console.log(ber);
        }).catch( jer => {
            console.log(jer);
        })
    </script>
</body>
</html>